home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / MacTCP Library 1.1 / Library / LowLevel ƒ / Headers ƒ / AddressXlation.h next >
Encoding:
C/C++ Source or Header  |  1995-12-04  |  15.4 KB  |  399 lines  |  [TEXT/SPM ]

  1. /* 
  2.     AddressXlation.h        
  3.     MacTCP name to address translation routines.
  4.  
  5.     Copyright Apple Computer, Inc. 1988-91
  6.     All rights reserved
  7.     
  8.     Modifications by Dave Nebinger (dnebing@andy.bgsu.edu), 01/30/94.
  9.     12/04/95 dn - Merged in the stuff from DNR.h from the old library.
  10. */    
  11.  
  12. #pragma once
  13.  
  14. #ifndef __H_AddressXlation__
  15. #define __H_AddressXlation__
  16.  
  17. #include <MacTCP.h>
  18.  
  19. #define NUM_ALT_ADDRS    4
  20.  
  21. enum AddrClasses {
  22.     A = 1,
  23.     NS,
  24.     CNAME = 5,
  25.     HINFO = 13,
  26.     MX = 15,
  27.     lastClass = 32767
  28. };
  29.  
  30. typedef enum AddrClasses AddrClasses; 
  31.  
  32. // procedure code numbers for DNR code segment
  33.  
  34. #define OPENRESOLVER    1
  35. #define CLOSERESOLVER    2
  36. #define STRTOADDR        3
  37. #define ADDRTOSTR        4
  38. #define ENUMCACHE        5
  39. #define ADDRTONAME    6
  40. #define HINFO            7
  41. #define MXINFO            8
  42.  
  43. #define kMaxResolverCalls    8            // maximum allowable active resolver queries
  44.  
  45. #define kHostFileCreatorType 'SPM ' // if the host file doesn't exist, one will be created with this creator type...
  46.  
  47. typedef struct HostInfo HostInfo,* HostInfoPtr,** HostInfoHdl;
  48. typedef struct HInfoRec HInfoRec,* HInfoPtr,** HInfoHdl;
  49. typedef struct MXRec MXRec,* MXPtr,** MXHdl;
  50. typedef struct ReturnRec ReturnRec,* ReturnPtr,** ReturnHdl;
  51. typedef struct CacheEntryRec CacheEntryRec,* CacheEntryPtr,** CacheEntryHdl;
  52.  
  53. // macros for allocating new blocks...
  54. #define NewHostInfoPtr() NEWPTR(HostInfoPtr,sizeof(HostInfo))
  55. #define DisposeHostInfoPtr(a) DISPOSEPTR(a)
  56. #define NewHostInfoHdl() NEWHDL(HostInfoHdl,sizeof(HostInfo))
  57. #define DisposeHostInfoHdl(a) DISPOSEHDL(a)
  58.  
  59. #define NewHInfoPtr() NEWPTR(HInfoPtr,sizeof(HInfoRec))
  60. #define DisposeHInfoPtr(a) DISPOSEPTR(a)
  61. #define NewHInfoHdl() NEWHDL(HInfoHdl,sizeof(HInfoRec))
  62. #define DisposeHInfoHdl(a) DISPOSEHDL(a)
  63.  
  64. #define NewMXPtr() NEWPTR(MXPtr,sizeof(MXRec))
  65. #define DisposeMXPtr(a) DISPOSEPTR(a)
  66. #define NewMXHdl() NEWHDL(MXHdl,sizeof(MXRec))
  67. #define DisposeMXHdl(a) DISPOSEHDL(a)
  68.  
  69. #define NewReturnPtr() NEWPTR(ReturnPtr,sizeof(ReturnRec))
  70. #define DisposeReturnPtr(a) DISPOSEPTR(a)
  71. #define NewReturnHdl() NEWHDL(ReturnHdl,sizeof(ReturnRec))
  72. #define DisposeReturnHdl(a) DISPOSEHDL(a)
  73.  
  74. #define NewCacheEntryPtr() NEWPTR(CacheEntryPtr,sizeof(CacheEntryRec))
  75. #define DisposeCacheEntryPtr(a) DISPOSEPTR(a)
  76. #define NewCacheEntryHdl() NEWHDL(CacheEntryHdl,sizeof(CacheEntryRec))
  77. #define DisposeCacheEntryHdl(a) DISPOSEHDL(a)
  78.  
  79. typedef pascal void (*EnumProcPtr)(CacheEntryPtr cacheEntryRecordPtr, char* userDataPtr);
  80. typedef pascal void (*HostInfoProcPtr)(HostInfoPtr hostInfoPtr, char* userDataPtr);
  81. typedef pascal void (*ReturnRecProcPtr)(ReturnPtr returnRecPtr, char* userDataPtr);
  82.  
  83. enum {
  84.     uppEnumProcInfo=kPascalStackBased
  85.         | STACK_ROUTINE_PARAMETER(1,SIZE_CODE(sizeof(CacheEntryPtr)))
  86.         | STACK_ROUTINE_PARAMETER(2,SIZE_CODE(sizeof(char*))),
  87.     uppHostInfoProcInfo=kPascalStackBased
  88.         | STACK_ROUTINE_PARAMETER(1,SIZE_CODE(sizeof(HostInfoPtr)))
  89.         | STACK_ROUTINE_PARAMETER(2,SIZE_CODE(sizeof(char*))),
  90.     uppReturnRecProcInfo=kPascalStackBased
  91.         | STACK_ROUTINE_PARAMETER(1,SIZE_CODE(sizeof(ReturnPtr)))
  92.         | STACK_ROUTINE_PARAMETER(2,SIZE_CODE(sizeof(char*)))
  93. };
  94.  
  95. #if USESROUTINEDESCRIPTORS
  96.     typedef UniversalProcPtr EnumUPP;
  97.     typedef UniversalProcPtr HostInfoUPP;
  98.     typedef UniversalProcPtr ReturnRecUPP;
  99.     
  100.     #define CallEnumProc(routine,cep,data)\
  101.         CallUniversalProc((UniversalProcPtr)routine,uppEnumProcInfo,(cep),(data))
  102.     #define NewEnumProc(routine)\
  103.         (EnumUPP)NewRoutineDescriptor((ProcPtr)(routine),uppEnumProcInfo,GetCurrentISA())
  104.     #define CallHostInfoProc(routine,cep,data)\
  105.         CallUniversalProc((UniversalProcPtr)routine,uppHostInfoProcInfo,(cep),(data))
  106.     #define NewHostInfoProc(routine)\
  107.         (HostInfoUPP)NewRoutineDescriptor((ProcPtr)(routine),uppHostInfoProcInfo,GetCurrentISA())
  108.     #define CallReturnRecProc(routine,cep,data)\
  109.         CallUniversalProc((UniversalProcPtr)routine,uppReturnRecProcInfo,(cep),(data))
  110.     #define NewReturnRecProc(routine)\
  111.         (ReturnRecUPP)NewRoutineDescriptor((ProcPtr)(routine),uppReturnRecProcInfo,GetCurrentISA())
  112. #else
  113.     typedef EnumProcPtr EnumUPP;
  114.     typedef HostInfoProcPtr HostInfoUPP;
  115.     typedef ReturnRecProcPtr ReturnRecUPP;
  116.     
  117.     #define CallEnumProc(routine,cep,data)\
  118.         (*(routine))((cep),(data))
  119.     #define NewEnumProc(routine)\
  120.         (EnumUPP)(routine)
  121.     #define CallHostInfoProc(routine,cep,data)\
  122.         (*(routine))((cep),(data))
  123.     #define NewHostInfoProc(routine)\
  124.         (HostInfoUPP)(routine)
  125.     #define CallReturnRecProc(routine,cep,data)\
  126.         (*(routine))((cep),(data))
  127.     #define NewReturnRecProc(routine)\
  128.         (ReturnRecUPP)(routine)
  129. #endif
  130.  
  131. // this macro will expand correctly for either case
  132. #define DisposeEnumProc(routine)\
  133.     DisposeRoutineDescriptor((UniversalProcPtr)routine)
  134. #define DisposeHostInfoProc(routine)\
  135.     DisposeRoutineDescriptor((UniversalProcPtr)routine)
  136. #define DisposeReturnRecProc(routine)\
  137.     DisposeRoutineDescriptor((UniversalProcPtr)routine)
  138.  
  139. #if defined(powerc) || defined (__powerc)
  140. #pragma options align=mac68k
  141. #endif
  142. struct HostInfo {
  143.     long            rtnCode;
  144.     char            cname[255];
  145.     ip_addr        addr[NUM_ALT_ADDRS];
  146. };
  147. #if defined(powerc) || defined(__powerc)
  148. #pragma options align=reset
  149. #endif
  150.  
  151. #if defined(powerc) || defined (__powerc)
  152. #pragma options align=mac68k
  153. #endif
  154. struct HInfoRec {
  155.     char            cpuType[30];
  156.     char            osType[30];
  157. };
  158. #if defined(powerc) || defined(__powerc)
  159. #pragma options align=reset
  160. #endif
  161.  
  162. #if defined(powerc) || defined (__powerc)
  163. #pragma options align=mac68k
  164. #endif
  165. struct MXRec {
  166.     unsigned short        preference;
  167.     char            exchange[255];
  168. };
  169. #if defined(powerc) || defined(__powerc)
  170. #pragma options align=reset
  171. #endif
  172.     
  173. #if defined(powerc) || defined (__powerc)
  174. #pragma options align=mac68k
  175. #endif
  176. struct ReturnRec {
  177.     long            rtnCode;
  178.     char            cname[255];
  179.     union {
  180.         ip_addr    addr[NUM_ALT_ADDRS];
  181.         HInfoRec    hinfo;
  182.         MXRec    mx;
  183.     } rdata;
  184. };
  185. #if defined(powerc) || defined(__powerc)
  186. #pragma options align=reset
  187. #endif
  188.  
  189. #if defined(powerc) || defined (__powerc)
  190. #pragma options align=mac68k
  191. #endif
  192. struct CacheEntryRecord {
  193.     char*        cname;
  194.     unsigned short        type;
  195.     unsigned short        cclass;
  196.     unsigned long            ttl;
  197.     union {
  198.         char*    name;
  199.         ip_addr    addr;
  200.     } rdata;
  201. };
  202. #if defined(powerc) || defined(__powerc)
  203. #pragma options align=reset
  204. #endif
  205.  
  206. typedef OSErr (*OpenResolverProcPtr) (long selector,char* filename);
  207. typedef OSErr (*CloseResolverProcPtr) (long selector);
  208. typedef OSErr (*StrToAddrProcPtr)(long selector, char* hostName,HostInfoPtr rtnStruct,HostInfoUPP resultProc, char* userData);
  209. typedef OSErr (*AddrToStrProcPtr)(long selector,ip_addr address, char* hostName);
  210. typedef OSErr (*EnumCacheProcPtr)(long selector, EnumUPP result, char* userData);
  211. typedef OSErr (*AddrToNameProcPtr)(long selector,ip_addr addr,HostInfoPtr rtnStruct,HostInfoUPP resultProc, char* userData);
  212. typedef OSErr (*HInfoProcPtr)(long selector, char* hostName,ReturnPtr returnRecPtr,ReturnRecUPP resultProc, char* userData);
  213. typedef OSErr (*MXInfoProcPtr)(long selector, char* hostName,ReturnPtr returnRecPtr,ReturnRecUPP resultProc, char* userData);
  214.  
  215. enum {
  216.     uppOpenResolverProcInfo=kCStackBased
  217.         | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  218.         | STACK_ROUTINE_PARAMETER(1,SIZE_CODE(sizeof(short)))    // short?
  219.         | STACK_ROUTINE_PARAMETER(2,SIZE_CODE(sizeof(char *))),
  220.     uppCloseResolverProcInfo=kCStackBased
  221.         | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  222.         | STACK_ROUTINE_PARAMETER(1,SIZE_CODE(sizeof(short))),
  223.     uppStrToAddrProcInfo = kCStackBased
  224.          | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  225.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  226.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
  227.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(HostInfoPtr)))
  228.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(HostInfoUPP)))
  229.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *))),
  230.     uppAddrToStrProcInfo = kCStackBased
  231.          | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  232.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  233.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(long)))
  234.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char *))),
  235.     uppEnumCacheProcInfo = kCStackBased
  236.          | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  237.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  238.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(EnumUPP)))
  239.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char *))),
  240.     uppAddrToNameProcInfo = kCStackBased
  241.         | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  242.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  243.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ip_addr)))
  244.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(HostInfoPtr)))
  245.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(HostInfoUPP)))
  246.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *))),
  247.     uppHInfoProcInfo = kCStackBased
  248.         | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  249.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  250.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
  251.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ReturnPtr)))
  252.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ReturnRecUPP)))
  253.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *))),
  254.     uppMXInfoProcInfo = kCStackBased
  255.         | RESULT_SIZE(SIZE_CODE(sizeof(long)))
  256.         | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))
  257.         | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(char *)))
  258.         | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(ReturnPtr)))
  259.         | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(ReturnRecUPP)))
  260.         | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(char *)))
  261. };
  262.  
  263. #if USESROUTINEDESCRIPTORS
  264.     typedef UniversalProcPtr OpenResolverUPP;
  265.     typedef UniversalProcPtr CloseResolverUPP;
  266.     typedef UniversalProcPtr StrToAddrUPP;
  267.     typedef UniversalProcPtr AddrToStrUPP;
  268.     typedef UniversalProcPtr EnumCacheUPP;
  269.     typedef UniversalProcPtr AddrToNameUPP;
  270.     typedef UniversalProcPtr HInfoUPP;
  271.     typedef UniversalProcPtr MXInfoUPP;
  272.     
  273.     #define CallOpenResolverProc(routine,selector,filename)\
  274.         CallUniversalProc((UniversalProcPtr)(routine),uppOpenResolverProcInfo,(selector),(filename))
  275.     #define NewOpenResolverProc(routine)\
  276.         (OpenResolverUPP)NewRoutineDescriptor((ProcPtr)(routine),uppOpenResolverProcInfo,GetCurrentISA())
  277.         
  278.     #define CallCloseResolverProc(routine,selector)\
  279.         CallUniversalProc((UniversalProcPtr)(routine),uppCloseResolverProcInfo,(selector))
  280.     #define NewCloseResolverProc(routine)\
  281.         (CloseResolverUPP)NewRoutineDescriptor((ProcPtr)(routine),uppCloseResolverProcInfo,GetCurrentISA())
  282.         
  283.     #define NewStrToAddrProc(userRoutine)\
  284.             (StrToAddrUPP) NewRoutineDescriptor(userRoutine, uppStrToAddrProcInfo, GetCurrentISA())
  285.     #define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultProc, userData)\
  286.             CallUniversalProc(userRoutine, uppStrToAddrProcInfo, selector, hostName, rtnStruct, resultProc, userData)
  287.  
  288.     #define NewAddrToStrProc(userRoutine)\
  289.             (AddrToStrUPP) NewRoutineDescriptor(userRoutine, uppAddrToStrProcInfo, GetCurrentISA())
  290.     #define CallAddrToStrProc(userRoutine, selector, address, hostName)\
  291.             CallUniversalProc(userRoutine, uppAddrToStrProcInfo, selector, address, hostName)
  292.  
  293.     #define NewEnumCacheProc(userRoutine)                       \
  294.             (EnumCacheUPP) NewRoutineDescriptor(userRoutine, uppEnumCacheProcInfo, GetCurrentISA())
  295.     #define CallEnumCacheProc(userRoutine, selector, result, userData)  \
  296.             CallUniversalProc(userRoutine, uppEnumCacheProcInfo, selector, result, userData)
  297.  
  298.     #define NewAddrToNameProc(userRoutine)                      \
  299.             (AddrToNameUPP) NewRoutineDescriptor(userRoutine, uppAddrToNameProcInfo, GetCurrentISA())
  300.     #define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultProc, userData)    \
  301.             CallUniversalProc(userRoutine, uppAddrToNameProcInfo, selector, addr, rtnStruct, resultProc, userData)
  302.  
  303.     #define NewHInfoProc(userRoutine)                       \
  304.             (HInfoUPP) NewRoutineDescriptor(userRoutine, uppHInfoProcInfo, GetCurrentISA())
  305.     #define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)  \
  306.             CallUniversalProc(userRoutine, uppHInfoProcInfo, selector, hostName, returnRecPtr, resultProc, userData)
  307.  
  308.     #define NewMXInfoProc(userRoutine)                      \
  309.             (MXInfoUPP) NewRoutineDescriptor(userRoutine, uppMXInfoProcInfo, GetCurrentISA())
  310.     #define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData) \
  311.             CallUniversalProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)
  312. #else
  313.     typedef OpenResolverProcPtr OpenResolverUPP;
  314.     typedef CloseResolverProcPtr CloseResolverUPP;
  315.     typedef StrToAddrProcPtr StrToAddrUPP;
  316.     typedef AddrToStrProcPtr AddrToStrUPP;
  317.     typedef EnumCacheProcPtr EnumCacheUPP;
  318.     typedef AddrToNameProcPtr AddrToNameUPP;
  319.     typedef HInfoProcPtr HInfoUPP;
  320.     typedef MXInfoProcPtr MXInfoUPP;
  321.     
  322.     #define CallOpenResolverProc(routine,selector,filename)\
  323.         (*routine)((selector),(filename))
  324.     #define NewOpenResolverProc(routine)\
  325.         (OpenResolverUPP)(routine)
  326.  
  327.     #define CallCloseResolverProc(routine,selector)\
  328.         (*routine)(selector)
  329.     #define NewCloseResolverProc(routine)\
  330.         (CloseResolverUPP)(routine)
  331.  
  332.     #define NewStrToAddrProc(userRoutine)\
  333.             (StrToAddrUPP)(userRoutine)
  334.     #define CallStrToAddrProc(userRoutine, selector, hostName, rtnStruct, resultProc, userData)\
  335.             (*userRoutine)(selector, hostName, rtnStruct, resultProc, userData)
  336.  
  337.     #define NewAddrToStrProc(userRoutine)\
  338.             (AddrToStrUPP)(userRoutine)
  339.     #define CallAddrToStrProc(userRoutine, selector, address, hostName)\
  340.             (*userRoutine)(selector, address, hostName)
  341.  
  342.     #define NewEnumCacheProc(userRoutine)                       \
  343.             (EnumCacheUPP)(userRoutine)
  344.     #define CallEnumCacheProc(userRoutine, selector, result, userData)  \
  345.             (*userRoutine)(selector, result, userData)
  346.  
  347.     #define NewAddrToNameProc(userRoutine)                      \
  348.             (AddrToNameUPP)(userRoutine)
  349.     #define CallAddrToNameProc(userRoutine, selector, addr, rtnStruct, resultProc, userData)    \
  350.             (*userRoutine)(selector, addr, rtnStruct, resultProc, userData)
  351.  
  352.     #define NewHInfoProc(userRoutine)                       \
  353.             (HInfoUPP)(userRoutine)
  354.     #define CallHInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData)  \
  355.             (*userRoutine)(selector, hostName, returnRecPtr, resultProc, userData)
  356.  
  357.     #define NewMXInfoProc(userRoutine)                      \
  358.             (MXInfoUPP)(userRoutine)
  359.     #define CallMXInfoProc(userRoutine, selector, hostName, returnRecPtr, resultProc, userData) \
  360.             (*userRoutine)(selector, hostName, returnRecPtr, resultProc, userData)
  361. #endif
  362.  
  363. // macros will expand correctly for either case
  364. #define DisposeOpenResolverProc(routine)\
  365.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  366. #define DisposeCloseResolverProc(routine)\
  367.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  368. #define DisposeStrToAddrProc(routine)\
  369.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  370. #define DisposeAddrToStrProc(routine)\
  371.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  372. #define DisposeEnumCacheProc(routine)\
  373.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  374. #define DisposeAddrToNameProc(routine)\
  375.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  376. #define DisposeHInfoProc(routine)\
  377.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  378. #define DisposeMXInfoProc(routine)\
  379.     DisposeRoutineDescriptor((UniversalProcPtr)(routine))
  380.  
  381. #ifdef __cplusplus
  382. extern "C" {
  383. #endif
  384.  
  385. extern OSErr OpenResolver(StringPtr fileName);
  386. extern OSErr CloseResolver(void);
  387.  
  388. extern OSErr StrToAddr(char* hostName,HostInfoPtr host,HostInfoUPP hiproc,char* userDataPtr);
  389. extern OSErr AddrToStr(ip_addr addr,char* addrStr);
  390. extern OSErr EnumCache(EnumUPP eproc,char* userDataPtr);
  391. extern OSErr AddrToName(ip_addr addr,HostInfoPtr host,HostInfoUPP hiproc,char* userDataPtr);
  392. extern OSErr HInfo(char* hostName,ReturnPtr ret,ReturnRecUPP rproc,char* userDataPtr);
  393. extern OSErr MXInfo(char* hostName,ReturnPtr ret,ReturnRecUPP rproc,char* userDataPtr);
  394.  
  395. #ifdef __cplusplus
  396. }
  397. #endif
  398.  
  399. #endif